பைதான் தொகுதி செயலாக்கத்தைப் பயன்படுத்தி பெரிய தரவுத் தொகுப்புகளைக் கையாள்வதற்கான முழுமையான வழிகாட்டி. முக்கிய உத்திகள், மேம்பட்ட நூலகங்கள் மற்றும் சிறந்த நடைமுறைகளைக் கற்றுக்கொள்ளுங்கள்.
பைதான் தொகுதி செயலாக்கத்தை மாஸ்டர் செய்தல்: பெரிய தரவுத் தொகுப்புகளைக் கையாள்வது குறித்த ஆழமான ஆய்வு
இன்றைய தரவு சார்ந்த உலகில், "பெரிய தரவு" என்ற சொல் ஒரு பரபரப்பான வார்த்தை மட்டுமல்ல; இது டெவலப்பர்கள், தரவு விஞ்ஞானிகள் மற்றும் பொறியாளர்களுக்கு தினசரி யதார்த்தமாகும். மெகாபைட்டுகளிலிருந்து ஜிகாபைட்டுகள், டெராபைட்டுகள் மற்றும் பெட்டாபைட்டுகளாக வளர்ந்துள்ள தரவுத் தொகுப்புகளை நாம் தொடர்ந்து எதிர்கொள்கிறோம். ஒரு CSV கோப்பை செயலாக்குவது போன்ற ஒரு எளிய பணி திடீரென தோல்வியடையும் போது ஒரு பொதுவான சவால் எழுகிறது. குற்றவாளி? ஒரு இழிவான MemoryError. ஒரு கணினியின் RAM-ல் ஒரு முழு தரவுத் தொகுப்பையும் ஏற்ற முயற்சிக்கும்போது இது நிகழ்கிறது, இது நவீன தரவின் அளவுகோலுக்கு பற்றாக்குறையாகவும், வரம்புக்குட்பட்ட வளமாகவும் உள்ளது.
இங்குதான் தொகுதி செயலாக்கம் வருகிறது. இது ஒரு புதிய அல்லது கவர்ச்சியான நுட்பம் அல்ல, ஆனால் அளவுகோல் சிக்கலுக்கு ஒரு அடிப்படை, வலுவான மற்றும் நேர்த்தியான தீர்வு. தரவை நிர்வகிக்கக்கூடிய துண்டுகளாக, அல்லது "தொகுதிகளாக" செயலாக்குவதன் மூலம், நிலையான வன்பொருளில் கிட்டத்தட்ட எந்த அளவிலான தரவுத் தொகுப்புகளையும் நாம் கையாள முடியும். இந்த அணுகுமுறை அளவிடக்கூடிய தரவுப் பைப்லைன்களின் அடித்தளமாகும், மேலும் பெரிய அளவிலான தகவல்களுடன் பணிபுரியும் எவருக்கும் ஒரு முக்கியமான திறமையாகும்.
இந்த விரிவான வழிகாட்டி பைதான் தொகுதி செயலாக்க உலகின் ஆழமான ஆய்வுக்கு உங்களை அழைத்துச் செல்லும். நாம் ஆராய்வோம்:
- தொகுதி செயலாக்கத்தின் பின்னணியில் உள்ள முக்கிய கருத்துகள் மற்றும் பெரிய அளவிலான தரவுப் பணிகளுக்கு ஏன் இது தவிர்க்க முடியாதது.
- நினைவக-செயல்திறன் கொண்ட கோப்பு கையாளுதலுக்கான ஜெனரேட்டர்கள் மற்றும் இட்டரேட்டர்களைப் பயன்படுத்தி அடிப்படை பைதான் நுட்பங்கள்.
- தொகுதிச் செயல்பாடுகளை எளிதாக்கும் மற்றும் துரிதப்படுத்தும் Pandas மற்றும் Dask போன்ற சக்திவாய்ந்த, உயர்மட்ட நூலகங்கள்.
- தரவுத்தளங்களிலிருந்து தரவை தொகுதி செயலாக்கம் செய்வதற்கான உத்திகள்.
- அனைத்து கருத்துக்களையும் இணைக்க ஒரு நடைமுறை, உண்மையான உலக ஆய்வு.
- வலுவான, பிழை-தாங்குதன்மை கொண்ட மற்றும் பராமரிக்கக்கூடிய தொகுதி செயலாக்க வேலைகளை உருவாக்குவதற்கான அத்தியாவசிய சிறந்த நடைமுறைகள்.
நீங்கள் ஒரு பெரிய லாக் கோப்பைச் செயலாக்க முயற்சிக்கும் தரவு பகுப்பாய்வாளராக இருந்தாலும் அல்லது தரவு சார்ந்த பயன்பாட்டை உருவாக்கும் மென்பொருள் பொறியாளராக இருந்தாலும், இந்த நுட்பங்களை மாஸ்டர் செய்வது எந்த அளவிலான தரவு சவால்களையும் வெல்ல உங்களுக்கு உதவும்.
தொகுதி செயலாக்கம் என்றால் என்ன, அது ஏன் அவசியம்?
தொகுதி செயலாக்கத்தை வரையறுத்தல்
அதன் மையத்தில், தொகுதி செயலாக்கம் ஒரு எளிய யோசனையாகும்: ஒரு முழு தரவுத் தொகுப்பையும் ஒரே நேரத்தில் செயலாக்குவதற்குப் பதிலாக, அதை சிறிய, தொடர்ச்சியான மற்றும் நிர்வகிக்கக்கூடிய துண்டுகளாகப் பிரித்து, அவை தொகுதிகள் என அழைக்கப்படுகின்றன. நீங்கள் ஒரு தொகுதியைப் படித்து, அதைச் செயலாக்கி, முடிவை எழுதி, பின்னர் அடுத்த தொகுதிக்குச் சென்று, முந்தைய தொகுதியை நினைவகத்திலிருந்து நீக்குவீர்கள். இந்தச் சுழற்சி முழு தரவுத் தொகுப்பும் செயலாக்கப்படும் வரை தொடரும்.
ஒரு பெரிய கலைக்களஞ்சியத்தைப் படிப்பது போல் இதை நினைத்துப் பாருங்கள். ஒரே உட்காரலில் அனைத்துத் தொகுதிகளையும் மனப்பாடம் செய்ய நீங்கள் முயற்சிக்க மாட்டீர்கள். மாறாக, நீங்கள் அதை பக்கம் பக்கமாக அல்லது அத்தியாயம் அத்தியாயமாகப் படிப்பீர்கள். ஒவ்வொரு அத்தியாயமும் தகவல்களின் ஒரு "தொகுதி" ஆகும். நீங்கள் அதைச் செயலாக்குகிறீர்கள் (படித்து புரிந்துகொள்கிறீர்கள்), பின்னர் அடுத்த அத்தியாயத்திற்குச் செல்கிறீர்கள். உங்கள் மூளை (RAM) தற்போதைய அத்தியாயத்தின் தகவல்களை மட்டுமே வைத்திருக்க வேண்டும், முழு கலைக்களஞ்சியத்தையும் அல்ல.
இந்த முறை, உதாரணமாக, 8GB RAM கொண்ட ஒரு அமைப்பு 100GB கோப்பை நினைவகம் தீர்ந்துபோகாமல் செயலாக்க அனுமதிக்கிறது, ஏனெனில் அது எந்த நேரத்திலும் தரவின் ஒரு சிறிய பகுதியை மட்டுமே வைத்திருக்க வேண்டும்.
"நினைவகச் சுவர்": ஏன் அனைத்தும் ஒரே நேரத்தில் தோல்வியடைகின்றன
தொகுதி செயலாக்கத்தை ஏற்றுக்கொள்வதற்கான மிகவும் பொதுவான காரணம் "நினைவகச் சுவரை" அடைவதுதான். data = file.readlines() அல்லது df = pd.read_csv('massive_file.csv') போன்ற குறியீட்டை எந்த சிறப்பு அளவுருக்களும் இல்லாமல் எழுதும்போது, பைதான் முழு கோப்பின் உள்ளடக்கத்தையும் உங்கள் கணினியின் RAM-ல் ஏற்றும்படி நீங்கள் அறிவுறுத்துகிறீர்கள்.
கிடைக்கக்கூடிய RAM-ஐ விட கோப்பு பெரியதாக இருந்தால், உங்கள் நிரல் பயங்கரமான MemoryError உடன் செயலிழக்கும். ஆனால் அதற்கு முன்பே சிக்கல்கள் தொடங்குகின்றன. உங்கள் நிரலின் நினைவகப் பயன்பாடு கணினியின் இயற்பியல் RAM வரம்பை அணுகும்போது, இயக்க முறைமை உங்கள் ஹார்ட் டிரைவ் அல்லது SSD-யின் ஒரு பகுதியை "மெய்நிகர் நினைவகம்" அல்லது "மாற்று கோப்பு" ஆகப் பயன்படுத்தத் தொடங்குகிறது. இந்த செயல்முறை, மாற்றியமைத்தல் என்று அழைக்கப்படுகிறது, இது நம்பமுடியாத அளவிற்கு மெதுவாக இருக்கும், ஏனெனில் சேமிப்பக டிரைவ்கள் RAM-ஐ விட பல மடங்கு மெதுவாக இருக்கும். கணினி RAM மற்றும் வட்டுக்கு இடையில் தரவை தொடர்ந்து மாற்றுவதால் உங்கள் பயன்பாட்டின் செயல்திறன் நின்றுவிடும், இது "த்ராஷிங்" என்று அழைக்கப்படும் ஒரு நிகழ்வு.
தொகுதி செயலாக்கம் இந்த சிக்கலை வடிவமைப்பால் முழுமையாகத் தவிர்க்கிறது. இது நினைவகப் பயன்பாட்டை குறைவாகவும் கணிக்கக்கூடியதாகவும் வைத்திருக்கிறது, உள்ளீட்டு கோப்பின் அளவு எதுவாக இருந்தாலும் உங்கள் பயன்பாடு பதிலளிக்கக்கூடியதாகவும் நிலையானதாகவும் இருப்பதை உறுதி செய்கிறது.
தொகுதி அணுகுமுறையின் முக்கிய நன்மைகள்
நினைவக நெருக்கடியைத் தீர்ப்பதுடன், தொகுதி செயலாக்கம் பல குறிப்பிடத்தக்க நன்மைகளை வழங்குகிறது, இது தொழில்முறை தரவு பொறியியலின் ஒரு மூலக்கல்லாக அமைகிறது:
- நினைவகத் திறன்: இது முதன்மையான நன்மை. ஒரு நேரத்தில் ஒரு சிறிய தரவுத் துண்டை மட்டும் நினைவகத்தில் வைத்திருப்பதன் மூலம், சாதாரண வன்பொருளில் பெரிய தரவுத்தொகுப்புகளைச் செயலாக்க முடியும்.
- அளவிடுதல்: நன்கு வடிவமைக்கப்பட்ட தொகுதி செயலாக்க ஸ்கிரிப்ட் இயற்கையாகவே அளவிடக்கூடியது. உங்கள் தரவு 10GB-யிலிருந்து 100GB ஆக வளர்ந்தால், அதே ஸ்கிரிப்ட் எந்த மாற்றமும் இல்லாமல் வேலை செய்யும். செயலாக்க நேரம் அதிகரிக்கும், ஆனால் நினைவக பயன்பாடு நிலையானதாக இருக்கும்.
- பிழை தாங்குதன்மை மற்றும் மீட்டெடுப்பு: பெரிய தரவு செயலாக்க வேலைகள் பல மணிநேரம் அல்லது நாட்கள் கூட இயங்கலாம். அனைத்தையும் ஒரே நேரத்தில் செயலாக்கும் போது ஒரு வேலை பாதியில் தோல்வியடைந்தால், அனைத்து முன்னேற்றமும் இழக்கப்படும். தொகுதி செயலாக்கத்தின் மூலம், உங்கள் அமைப்பை மிகவும் மீள்திறன் கொண்டதாக வடிவமைக்கலாம். தொகுதி #500 ஐ செயலாக்கும்போது ஒரு பிழை ஏற்பட்டால், அந்த குறிப்பிட்ட தொகுதியை மட்டுமே மீண்டும் செயலாக்க வேண்டியிருக்கலாம், அல்லது தொகுதி #501 இலிருந்து மீண்டும் தொடங்கலாம், இது கணிசமான நேரத்தையும் வளங்களையும் மிச்சப்படுத்தும்.
- இணை செயல்பாடு வாய்ப்புகள்: தொகுதிகள் பெரும்பாலும் ஒன்றுக்கொன்று சுயாதீனமாக இருப்பதால், அவை ஒரே நேரத்தில் செயலாக்கப்படலாம். பல CPU கோர்கள் வெவ்வேறு தொகுதிகளில் ஒரே நேரத்தில் வேலை செய்ய மல்டி-த்ரெடிங் அல்லது மல்டி-பிராசஸிங் பயன்படுத்தலாம், இது மொத்த செயலாக்க நேரத்தை வியத்தகு முறையில் குறைக்கும்.
தொகுதி செயலாக்கத்திற்கான முக்கிய பைதான் நுட்பங்கள்
உயர்மட்ட நூலகங்களுக்குச் செல்வதற்கு முன், நினைவக-செயல்திறன் கொண்ட செயலாக்கத்தை சாத்தியமாக்கும் அடிப்படை பைதான் கட்டமைப்புகளைப் புரிந்துகொள்வது மிக முக்கியம். இவை இட்டரேட்டர்கள் மற்றும் மிக முக்கியமாக, ஜெனரேட்டர்கள்.
அடித்தளம்: பைதான் ஜெனரேட்டர்கள் மற்றும் the `yield` கீவேர்ட்
பைத்தானில் மந்தமான மதிப்பீட்டின் இதயம் மற்றும் ஆன்மா ஜெனரேட்டர்கள். ஒரு ஜெனரேட்டர் ஒரு சிறப்பு வகைச் செயல்பாடு ஆகும், இது return உடன் ஒற்றை மதிப்பைத் திருப்பித் தருவதற்குப் பதிலாக, yield கீவேர்ட்டைப் பயன்படுத்தி மதிப்புகளின் வரிசையை உருவாக்குகிறது. ஒரு ஜெனரேட்டர் செயல்பாடு அழைக்கப்படும்போது, அது ஒரு ஜெனரேட்டர் பொருளைத் திருப்பித் தருகிறது, அது ஒரு இட்டரேட்டர் ஆகும். இந்த பொருளின் மீது நீங்கள் இட்டரேட் செய்யத் தொடங்கும் வரை செயல்பாட்டிற்குள் உள்ள குறியீடு செயல்படாது.
ஒவ்வொரு முறையும் நீங்கள் ஜெனரேட்டரிடமிருந்து ஒரு மதிப்பைக் கோரும்போது (எ.கா., ஒரு for லூப்பில்), அது ஒரு yield கூற்றை அடையும் வரை செயல்பாடு செயல்படும். பின்னர் அது மதிப்பை "yield" செய்து, அதன் நிலையை நிறுத்தி, அடுத்த அழைப்புக்காக காத்திருக்கும். இது ஒரு வழக்கமான செயல்பாட்டிலிருந்து முற்றிலும் வேறுபட்டது, அது எல்லாவற்றையும் கணக்கிட்டு, ஒரு பட்டியலில் சேமித்து, முழு பட்டியலையும் ஒரே நேரத்தில் திருப்பித் தருகிறது.
ஒரு கிளாசிக் கோப்பு வாசிப்பு உதாரணத்துடன் வித்தியாசத்தைப் பார்ப்போம்.
திறமையற்ற வழி (அனைத்து வரிகளையும் நினைவகத்தில் ஏற்றுதல்):
def read_large_file_inefficient(file_path):
with open(file_path, 'r') as f:
return f.readlines() # Reads the ENTIRE file into a list in RAM
# Usage:
# If 'large_dataset.csv' is 10GB, this will try to allocate 10GB+ of RAM.
# This will likely crash with a MemoryError.
# lines = read_large_file_inefficient('large_dataset.csv')
திறமையான வழி (ஜெனரேட்டரைப் பயன்படுத்துதல்):
பைதான் கோப்புப் பொருள்கள் தாங்களே இட்டரேட்டர்களாகும், அவை வரிக்கு வரி படிக்கின்றன. இதை நாம் நமது சொந்த ஜெனரேட்டர் செயல்பாட்டில் தெளிவுக்காகச் சுற்றலாம்.
def read_large_file_efficient(file_path):
"""
A generator function to read a file line by line without loading it all into memory.
"""
with open(file_path, 'r') as f:
for line in f:
yield line.strip()
# Usage:
# This creates a generator object. No data is read into memory yet.
line_generator = read_large_file_efficient('large_dataset.csv')
# The file is read one line at a time as we loop.
# Memory usage is minimal, holding only one line at a time.
for log_entry in line_generator:
# process(log_entry)
pass
ஒரு ஜெனரேட்டரைப் பயன்படுத்துவதன் மூலம், கோப்பின் அளவு எதுவாக இருந்தாலும், நமது நினைவகப் பயன்பாடு சிறியதாகவும் நிலையானதாகவும் இருக்கும்.
பைட்டுகள் தொகுதிகளாகப் பெரிய கோப்புகளைப் படித்தல்
சில சமயங்களில், வரிக்கு வரி செயலாக்குவது உகந்ததல்ல, குறிப்பாக உரை அல்லாத கோப்புகளுடன் அல்லது பல வரிகளில் பரவியிருக்கும் பதிவுகளைப் பிரிக்க வேண்டியிருக்கும் போது. இந்த சந்தர்ப்பங்களில், நீங்கள் `file.read(chunk_size)` ஐப் பயன்படுத்தி நிலையான அளவுள்ள பைட்டுகளின் தொகுதிகளாக கோப்பைப் படிக்கலாம்.
def read_file_in_chunks(file_path, chunk_size=65536): # 64KB chunk size
"""
A generator that reads a file in fixed-size byte chunks.
"""
with open(file_path, 'rb') as f: # Open in binary mode 'rb'
while True:
chunk = f.read(chunk_size)
if not chunk:
break # End of file
yield chunk
# Usage:
# for data_chunk in read_file_in_chunks('large_binary_file.dat'):
# process_binary_data(data_chunk)
உரை கோப்புகளைக் கையாளும் போது இந்த முறையின் ஒரு பொதுவான சவால் என்னவென்றால், ஒரு தொகுதி ஒரு வரியின் நடுவில் முடிவடையலாம். ஒரு வலுவான செயலாக்கம் இந்த பகுதி வரிகளைக் கையாள வேண்டும், ஆனால் பல பயன்பாட்டு நிகழ்வுகளுக்கு, Pandas (அடுத்து வரும்) போன்ற நூலகங்கள் இந்த சிக்கலை உங்களுக்காக நிர்வகிக்கின்றன.
மீண்டும் பயன்படுத்தக்கூடிய தொகுதி ஜெனரேட்டரை உருவாக்குதல்
இப்போது நம்மிடம் ஒரு பெரிய தரவுத் தொகுப்பில் (நமது `read_large_file_efficient` ஜெனரேட்டர் போன்றவை) திரும்பத் திரும்பச் செயல்படக்கூடிய நினைவக-செயல்திறன் கொண்ட வழி இருப்பதால், இந்த உருப்படிகளை தொகுதிகளாக தொகுக்க ஒரு வழி தேவை. எந்த இட்டரேபிளையும் எடுத்துக்கொண்டு, ஒரு குறிப்பிட்ட அளவிலான பட்டியல்களை உருவாக்கும் மற்றொரு ஜெனரேட்டரை நாம் எழுதலாம்.
from itertools import islice
def batch_generator(iterable, batch_size):
"""
A generator that takes an iterable and yields batches of a specified size.
"""
iterator = iter(iterable)
while True:
batch = list(islice(iterator, batch_size))
if not batch:
break
yield batch
# --- Putting It All Together ---
# 1. Create a generator to read lines efficiently
line_gen = read_large_file_efficient('large_dataset.csv')
# 2. Create a batch generator to group lines into batches of 1000
batch_gen = batch_generator(line_gen, 1000)
# 3. Process the data batch by batch
for i, batch in enumerate(batch_gen):
print(f"Processing batch {i+1} with {len(batch)} items...")
# Here, 'batch' is a list of 1000 lines.
# You can now perform your processing on this manageable chunk.
# For example, bulk insert this batch into a database.
# process_batch(batch)
ஒரு தரவு மூல ஜெனரேட்டரை ஒரு தொகுதி ஜெனரேட்டருடன் இணைக்கும் இந்த முறை—பைத்தானில் தனிப்பயன் தொகுதி செயலாக்கப் பைப்லைன்களுக்கான ஒரு சக்திவாய்ந்த மற்றும் மீண்டும் பயன்படுத்தக்கூடிய டெம்ப்ளேட் ஆகும்.
தொகுதி செயலாக்கத்திற்கான சக்திவாய்ந்த நூலகங்களைப் பயன்படுத்துதல்
முக்கிய பைதான் நுட்பங்கள் அடிப்படையானவை என்றாலும், தரவு அறிவியல் மற்றும் பொறியியல் நூலகங்களின் செழுமையான சூழல் உயர்மட்ட சுருக்கங்களை வழங்குகிறது, இது தொகுதி செயலாக்கத்தை இன்னும் எளிதாகவும் சக்திவாய்ந்ததாகவும் ஆக்குகிறது.
Pandas: `chunksize` உடன் பெரிய CSV-களைக் கையாளுதல்
Pandas என்பது பைத்தானில் தரவு கையாளுதலுக்கான ஒரு முக்கியமான நூலகமாகும், ஆனால் அதன் இயல்புநிலை `read_csv` செயல்பாடு பெரிய கோப்புகளுடன் விரைவாக `MemoryError` க்கு வழிவகுக்கும். அதிர்ஷ்டவசமாக, Pandas டெவலப்பர்கள் ஒரு எளிய மற்றும் நேர்த்தியான தீர்வை வழங்கினர்: `chunksize` அளவுரு.
நீங்கள் `chunksize` ஐக் குறிப்பிடும்போது, `pd.read_csv()` ஒற்றை DataFrame-ஐத் திருப்பித் தரவில்லை. அதற்குப் பதிலாக, அது குறிப்பிட்ட அளவிலான (வரிகளின் எண்ணிக்கை) DataFrames-ஐ உருவாக்கும் ஒரு இட்டரேட்டரைத் திருப்பித் தருகிறது.
import pandas as pd
file_path = 'massive_sales_data.csv'
chunk_size = 100000 # Process 100,000 rows at a time
# This creates an iterator object
df_iterator = pd.read_csv(file_path, chunksize=chunk_size)
total_revenue = 0
total_transactions = 0
print("Starting batch processing with Pandas...")
for i, chunk_df in enumerate(df_iterator):
# 'chunk_df' is a Pandas DataFrame with up to 100,000 rows
print(f"Processing chunk {i+1} with {len(chunk_df)} rows...")
# Example processing: Calculate statistics on the chunk
chunk_revenue = (chunk_df['quantity'] * chunk_df['price']).sum()
total_revenue += chunk_revenue
total_transactions += len(chunk_df)
# You could also perform more complex transformations, filtering,
# or save the processed chunk to a new file or database.
# filtered_chunk = chunk_df[chunk_df['region'] == 'APAC']
# filtered_chunk.to_sql('apac_sales', con=db_connection, if_exists='append', index=False)
print(f"\nProcessing complete.")
print(f"Total Transactions: {total_transactions}")
print(f"Total Revenue: {total_revenue:.2f}")
இந்த அணுகுமுறை, ஒவ்வொரு தொகுதியிலும் Pandas-ன் வெக்டரைஸ்டு செயல்பாடுகளின் சக்தியை தொகுதி செயலாக்கத்தின் நினைவகத் திறனுடன் இணைக்கிறது. `read_json` (`lines=True` உடன்) மற்றும் `read_sql_table` போன்ற பல Pandas வாசிப்பு செயல்பாடுகளும் ஒரு `chunksize` அளவுருவை ஆதரிக்கின்றன.
டாஸ்க்: மையத்திற்கு வெளியே உள்ள தரவுகளுக்கான இணைச் செயலாக்கம்
உங்கள் தரவுத்தொகுப்பு மிகவும் பெரியதாக இருந்தால், ஒரு ஒற்றை தொகுதி கூட நினைவகத்திற்கு பெரியதாக இருந்தால் அல்லது உங்கள் மாற்றங்கள் ஒரு எளிய சுழற்சிக்கு மிகவும் சிக்கலானதாக இருந்தால் என்ன செய்வது? இங்குதான் டாஸ்க் பிரகாசிக்கிறது. டாஸ்க் என்பது பைத்தானுக்கான ஒரு நெகிழ்வான இணை கணினி நூலகமாகும், இது NumPy, Pandas மற்றும் Scikit-Learn இன் பிரபலமான API-களை அளவிடுகிறது.
டாஸ்க் டேட்டாஃபிரேம்கள் Pandas டேட்டாஃபிரேம்கள் போலவே தோற்றமளிக்கின்றன மற்றும் செயல்படுகின்றன, ஆனால் அவை உள்ளுக்குள் வித்தியாசமாகச் செயல்படுகின்றன. ஒரு டாஸ்க் டேட்டாஃபிரேம் ஒரு குறியீட்டில் பிரிக்கப்பட்ட பல சிறிய Pandas டேட்டாஃபிரேம்களால் ஆனது. இந்த சிறிய டேட்டாஃபிரேம்கள் வட்டில் வாழலாம் மற்றும் பல CPU கோர்கள் அல்லது ஒரு கிளஸ்டரில் உள்ள பல இயந்திரங்களில் இணையாகச் செயலாக்கப்படலாம்.
டாஸ்கில் ஒரு முக்கிய கருத்து மந்தமான மதிப்பீடு ஆகும். நீங்கள் டாஸ்க் குறியீட்டை எழுதும்போது, நீங்கள் உடனடியாகக் கணக்கீட்டைச் செயல்படுத்துவதில்லை. அதற்குப் பதிலாக, நீங்கள் ஒரு பணி வரைபடத்தை உருவாக்குகிறீர்கள். நீங்கள் `.compute()` முறையை வெளிப்படையாக அழைக்கும்போதுதான் கணக்கீடு தொடங்குகிறது.
import dask.dataframe as dd
# Dask's read_csv looks similar to Pandas, but it's lazy.
# It immediately returns a Dask DataFrame object without loading data.
# Dask automatically determines a good chunk size ('blocksize').
# You can use wildcards to read multiple files.
ddf = dd.read_csv('sales_data/2023-*.csv')
# Define a series of complex transformations.
# None of this code executes yet; it just builds the task graph.
ddf['sale_date'] = dd.to_datetime(ddf['sale_date'])
ddf['revenue'] = ddf['quantity'] * ddf['price']
# Calculate the total revenue per month
revenue_by_month = ddf.groupby(ddf.sale_date.dt.month)['revenue'].sum()
# Now, trigger the computation.
# Dask will read the data in chunks, process them in parallel,
# and aggregate the results.
print("Starting Dask computation...")
result = revenue_by_month.compute()
print("\nComputation finished.")
print(result)
Pandas `chunksize` க்கு மேல் டாஸ்கை எப்போது தேர்வு செய்ய வேண்டும்:
- உங்கள் தரவுத்தொகுப்பு உங்கள் கணினியின் RAM-ஐ விட பெரியதாக இருக்கும்போது (மையத்திற்கு வெளியே கணினி).
- உங்கள் கணக்கீடுகள் சிக்கலானதாக இருக்கும்போது மற்றும் பல CPU கோர்கள் அல்லது ஒரு கிளஸ்டர் முழுவதும் இணையாகச் செயல்படுத்தப்படலாம்.
- நீங்கள் இணையாகப் படிக்கக்கூடிய பல கோப்புகளின் தொகுப்புகளுடன் பணிபுரியும் போது.
தரவுத்தள தொடர்பு: கர்சர்கள் மற்றும் தொகுதி செயல்பாடுகள்
தொகுதி செயலாக்கம் கோப்புகளுக்கு மட்டும் அல்ல. கிளையன்ட் பயன்பாடு மற்றும் தரவுத்தள சர்வர் இரண்டையும் ஓவர்லோட் செய்வதைத் தவிர்க்க தரவுத்தளங்களுடன் தொடர்பு கொள்ளும்போது இது சமமாக முக்கியமானது.
பெரிய முடிவுகளைப் பெறுதல்:
ஒரு தரவுத்தள அட்டவணையில் இருந்து மில்லியன் கணக்கான வரிகளை கிளையன்ட் பக்க பட்டியல் அல்லது டேட்டாஃபிரேமில் ஏற்றுவது ஒரு `MemoryError` க்கான வழிமுறையாகும். தரவை தொகுதிகளாகப் பெறும் கர்சர்களைப் பயன்படுத்துவதே இதற்குத் தீர்வு.
PostgreSQL க்கான `psycopg2` போன்ற நூலகங்களுடன், நீங்கள் ஒரு "பெயரிடப்பட்ட கர்சரை" (ஒரு சர்வர் பக்க கர்சர்) பயன்படுத்தலாம், இது ஒரு குறிப்பிட்ட எண்ணிக்கையிலான வரிகளை ஒரு நேரத்தில் பெறுகிறது.
import psycopg2
import psycopg2.extras
# Assume 'conn' is an existing database connection
# Use a with statement to ensure the cursor is closed
with conn.cursor(name='my_server_side_cursor', cursor_factory=psycopg2.extras.DictCursor) as cursor:
cursor.itersize = 2000 # Fetch 2000 rows from the server at a time
cursor.execute("SELECT * FROM user_events WHERE event_date > '2023-01-01'")
for row in cursor:
# 'row' is a dictionary-like object for one record
# Process each row with minimal memory overhead
# process_event(row)
pass
உங்கள் தரவுத்தள டிரைவர் சர்வர்-பக்க கர்சர்களை ஆதரிக்கவில்லை என்றால், நீங்கள் ஒரு சுழற்சியில் `LIMIT` மற்றும் `OFFSET` ஐப் பயன்படுத்தி கைமுறை தொகுதி செயலாக்கத்தை செயல்படுத்தலாம், இருப்பினும் இது மிக பெரிய அட்டவணைகளுக்கு குறைந்த செயல்திறன் கொண்டதாக இருக்கலாம்.
பெரிய அளவிலான தரவைச் செருகுதல்:
ஒரு சுழற்சியில் வரிக்கு வரி செருகுவது ஒவ்வொரு `INSERT` கூற்றின் நெட்வொர்க் ஓவர்ஹெட் காரணமாக மிகவும் திறமையற்றது. சரியான வழி `cursor.executemany()` போன்ற தொகுதி செருகுதல் முறைகளைப் பயன்படுத்துவதாகும்.
# 'data_to_insert' is a list of tuples, e.g., [(1, 'A'), (2, 'B'), ...]
# Let's say it has 10,000 items.
sql_insert = "INSERT INTO my_table (id, value) VALUES (%s, %s)"
with conn.cursor() as cursor:
# This sends all 10,000 records to the database in a single, efficient operation.
cursor.executemany(sql_insert, data_to_insert)
conn.commit() # Don't forget to commit the transaction
இந்த அணுகுமுறை தரவுத்தள ரவுண்ட்-டிரிப்களை வியத்தகு முறையில் குறைக்கிறது மற்றும் கணிசமாக வேகமாகவும் திறமையாகவும் உள்ளது.
உண்மையான உலக ஆய்வு: டெராபைட்டுகள் அளவிலான பதிவுத் தரவைச் செயலாக்குதல்
இந்த கருத்துக்களை ஒரு யதார்த்தமான காட்சியில் ஒருங்கிணைப்போம். நீங்கள் ஒரு உலகளாவிய இ-காமர்ஸ் நிறுவனத்தில் தரவு பொறியாளராக இருப்பதாக கற்பனை செய்து பாருங்கள். பயனர் செயல்பாடு குறித்த அறிக்கையை உருவாக்க தினசரி சர்வர் பதிவுகளைச் செயலாக்குவதே உங்கள் பணி. பதிவுகள் சுருக்கப்பட்ட JSON வரி கோப்புகளில் (`.jsonl.gz`) சேமிக்கப்படுகின்றன, ஒவ்வொரு நாளின் தரவும் பல நூறு ஜிகாபைட்டுகளைக் கொண்டது.
சவால்
- தரவு அளவு: ஒரு நாளைக்கு 500GB சுருக்கப்பட்ட பதிவுத் தரவு. சுருக்கப்படாமல், இது பல டெராபைட்டுகள்.
- தரவு வடிவம்: கோப்பில் உள்ள ஒவ்வொரு வரியும் ஒரு நிகழ்வை பிரதிநிதித்துவப்படுத்தும் தனிப்பட்ட JSON பொருளாகும்.
- நோக்கம்: ஒரு குறிப்பிட்ட நாளுக்கு, ஒரு தயாரிப்பைப் பார்த்த தனிப்பட்ட பயனர்களின் எண்ணிக்கை மற்றும் வாங்குதல் செய்தவர்களின் எண்ணிக்கையைக் கணக்கிடுங்கள்.
- கட்டுப்பாடு: செயலாக்கம் 64GB RAM கொண்ட ஒற்றை இயந்திரத்தில் செய்யப்பட வேண்டும்.
எளிமையான (மற்றும் தோல்வியுற்ற) அணுகுமுறை
ஒரு இளைய டெவலப்பர் முதலில் முழு கோப்பையும் ஒரே நேரத்தில் படித்து பகுப்பாய்வு செய்ய முயற்சி செய்யலாம்.
import gzip
import json
def process_logs_naive(file_path):
all_events = []
with gzip.open(file_path, 'rt') as f:
for line in f:
all_events.append(json.loads(line))
# ... more code to process 'all_events'
# This will fail with a MemoryError long before the loop finishes.
இந்த அணுகுமுறை தோல்வியடைய விதிக்கப்பட்டுள்ளது. `all_events` பட்டியல் டெராபைட்டுகள் RAM தேவைப்படும்.
தீர்வு: ஒரு அளவிடக்கூடிய தொகுதி செயலாக்கப் பைப்லைன்
நாம் விவாதித்த நுட்பங்களைப் பயன்படுத்தி ஒரு வலுவான பைப்லைனை உருவாக்குவோம்.
- ஸ்ட்ரீம் மற்றும் டிகம்ப்ரஸ்: முழு கோப்பையும் முதலில் வட்டில் டிகம்ப்ரஸ் செய்யாமல், சுருக்கப்பட்ட கோப்பை வரிக்கு வரி படிக்கவும்.
- தொகுத்தல்: பகுப்பாய்வு செய்யப்பட்ட JSON பொருள்களை நிர்வகிக்கக்கூடிய தொகுதிகளாகக் குழுவாக்குங்கள்.
- இணை செயலாக்கம்: வேலை வேகப்படுத்த பல CPU கோர்களைப் பயன்படுத்தி தொகுதிகளை ஒரே நேரத்தில் செயலாக்கவும்.
- ஒன்றுசேர்த்தல்: இறுதி அறிக்கையை உருவாக்க ஒவ்வொரு இணை பணியாளரிடமிருந்தும் வரும் முடிவுகளை இணைக்கவும்.
குறியீடு செயலாக்க ஓவியம்
முழுமையான, அளவிடக்கூடிய ஸ்கிரிப்ட் எப்படி இருக்கும் என்பது இங்கே:
import gzip
import json
from concurrent.futures import ProcessPoolExecutor, as_completed
from collections import defaultdict
# Reusable batching generator from earlier
def batch_generator(iterable, batch_size):
from itertools import islice
iterator = iter(iterable)
while True:
batch = list(islice(iterator, batch_size))
if not batch:
break
yield batch
def read_and_parse_logs(file_path):
"""
A generator that reads a gzipped JSON-line file,
parses each line, and yields the resulting dictionary.
Handles potential JSON decoding errors gracefully.
"""
with gzip.open(file_path, 'rt', encoding='utf-8') as f:
for line in f:
try:
yield json.loads(line)
except json.JSONDecodeError:
# Log this error in a real system
continue
def process_batch(batch):
"""
This function is executed by a worker process.
It takes one batch of log events and calculates partial results.
"""
viewed_product_users = set()
purchased_users = set()
for event in batch:
event_type = event.get('type')
user_id = event.get('userId')
if not user_id:
continue
if event_type == 'PRODUCT_VIEW':
viewed_product_users.add(user_id)
elif event_type == 'PURCHASE_SUCCESS':
purchased_users.add(user_id)
return viewed_product_users, purchased_users
def main(log_file, batch_size=50000, max_workers=4):
"""
Main function to orchestrate the batch processing pipeline.
"""
print(f"Starting analysis of {log_file}...")
# 1. Create a generator for reading and parsing log events
log_event_generator = read_and_parse_logs(log_file)
# 2. Create a generator for batching the log events
log_batches = batch_generator(log_event_generator, batch_size)
# Global sets to aggregate results from all workers
total_viewed_users = set()
total_purchased_users = set()
# 3. Use ProcessPoolExecutor for parallel processing
with ProcessPoolExecutor(max_workers=max_workers) as executor:
# Submit each batch to the process pool
future_to_batch = {executor.submit(process_batch, batch): batch for batch in log_batches}
processed_batches = 0
for future in as_completed(future_to_batch):
try:
# Get the result from the completed future
viewed_users_partial, purchased_users_partial = future.result()
# 4. Aggregate the results
total_viewed_users.update(viewed_users_partial)
total_purchased_users.update(purchased_users_partial)
processed_batches += 1
if processed_batches % 10 == 0:
print(f"Processed {processed_batches} batches...")
except Exception as exc:
print(f'A batch generated an exception: {exc}')
print("\n--- Analysis Complete ---")
print(f"Unique users who viewed a product: {len(total_viewed_users)}")
print(f"Unique users who made a purchase: {len(total_purchased_users)}")
if __name__ == '__main__':
LOG_FILE_PATH = 'server_logs_2023-10-26.jsonl.gz'
# On a real system, you would pass this path as an argument
main(LOG_FILE_PATH, max_workers=8)
இந்த பைப்லைன் வலுவானது மற்றும் அளவிடக்கூடியது. இது ஒரு பணிச்சுமை செயல்முறைக்கு ஒரு தொகுதிக்கு மேல் RAM-ல் வைத்திருக்காததால் குறைந்த நினைவகப் பயன்பாட்டைப் பராமரிக்கிறது. இது பல CPU கோர்களைப் பயன்படுத்தி இது போன்ற CPU-சார்ந்த பணியை கணிசமாக வேகப்படுத்துகிறது. தரவு அளவு இரட்டிப்பானால், இந்த ஸ்கிரிப்ட் இன்னும் வெற்றிகரமாக இயங்கும்; இதற்கு அதிக நேரம் எடுக்கும்.
வலுவான தொகுதி செயலாக்கத்திற்கான சிறந்த நடைமுறைகள்
வேலை செய்யும் ஒரு ஸ்கிரிப்டை உருவாக்குவது ஒரு விஷயம்; உற்பத்திக்குத் தயாரான, நம்பகமான தொகுதி செயலாக்க வேலையை உருவாக்குவது வேறு விஷயம். பின்பற்ற வேண்டிய சில அத்தியாவசிய சிறந்த நடைமுறைகள் இங்கே.
சமநிலையான செயல்பாடு முக்கியமானது
ஒரு செயல்பாடு பல முறை இயக்கப்பட்டால் ஒரு முறை இயங்குவதைப் போலவே அதே முடிவைத் தந்தால் அது சமநிலையான செயல்பாடு ஆகும். தொகுதி வேலைகளுக்கு இது ஒரு முக்கியமான பண்பு. ஏன்? ஏனென்றால் வேலைகள் தோல்வியடைகின்றன. நெட்வொர்க்குகள் துண்டிக்கப்படுகின்றன, சர்வர்கள் மறுதொடக்கம் செய்யப்படுகின்றன, பிழைகள் ஏற்படுகின்றன. உங்கள் தரவைச் சிதைக்காமல் (எ.கா., நகல் பதிவுகளைச் செருகுவது அல்லது வருவாயை இருமுறை கணக்கிடுவது) தோல்வியுற்ற வேலையை பாதுகாப்பாக மீண்டும் இயக்க உங்களுக்குத் தெரிய வேண்டும்.
உதாரணம்: பதிவுகளுக்கு ஒரு எளிய `INSERT` கூற்றைப் பயன்படுத்துவதற்குப் பதிலாக, ஒரு `UPSERT` (இருந்தால் புதுப்பிக்கவும், இல்லையெனில் செருகவும்) அல்லது ஒரு தனிப்பட்ட கீ-ஐ நம்பியிருக்கும் ஒத்த பொறிமுறையைப் பயன்படுத்தவும். இதன் மூலம், ஏற்கனவே பகுதியாக சேமிக்கப்பட்ட ஒரு தொகுதியை மீண்டும் செயலாக்குவது நகல்களை உருவாக்காது.
திறமையான பிழை கையாளுதல் மற்றும் பதிவு செய்தல்
உங்கள் தொகுதி வேலை ஒரு கருப்பு பெட்டியாக இருக்கக்கூடாது. பிழைத்திருத்தம் மற்றும் கண்காணிப்புக்கு விரிவான பதிவு அவசியம்.
- முன்னேற்றத்தைப் பதிவு செய்தல்: வேலையின் தொடக்கத்திலும் முடிவிலும், மற்றும் செயலாக்கத்தின் போது அவ்வப்போது செய்திகளைப் பதிவு செய்யவும் (எ.கா., "5000 தொகுதிகளில் 100 வது தொகுதியைத் தொடங்குகிறது..."). இது ஒரு வேலை எங்கு தோல்வியடைந்தது என்பதைப் புரிந்துகொள்ளவும், அதன் முன்னேற்றத்தை மதிப்பிடவும் உதவுகிறது.
- சிதைந்த தரவைக் கையாளுதல்: 10,000 தொகுதிகளில் ஒரு ஒற்றை தவறாக வடிவமைக்கப்பட்ட பதிவு முழு வேலையையும் செயலிழக்கச் செய்யக்கூடாது. உங்கள் பதிவு-நிலை செயலாக்கத்தை ஒரு `try...except` பிளாக்கில் சுற்றவும். பிழை மற்றும் சிக்கலான தரவைப் பதிவுசெய்து, பின்னர் ஒரு உத்தியைத் தீர்மானிக்கவும்: மோசமான பதிவைத் தவிர்க்கவும், பிற்கால ஆய்வுக்காக அதை ஒரு "தனிமைப்படுத்தப்பட்ட" பகுதிக்கு நகர்த்தவும், அல்லது தரவு ஒருமைப்பாடு மிக முக்கியமாக இருந்தால் முழு தொகுதியையும் தோல்வியடையச் செய்யவும்.
- கட்டமைக்கப்பட்ட பதிவு: உங்கள் பதிவுகளை கண்காணிக்கும் கருவிகளால் எளிதாகத் தேடக்கூடியதாகவும் பகுப்பாய்வு செய்யக்கூடியதாகவும் மாற்ற கட்டமைக்கப்பட்ட பதிவு முறையைப் பயன்படுத்தவும் (எ.கா., JSON பொருள்களைப் பதிவு செய்தல்). தொகுதி ID, பதிவு ID மற்றும் நேர முத்திரைகள் போன்ற சூழலைச் சேர்க்கவும்.
கண்காணிப்பு மற்றும் சோதனைச் சாவடி
பல மணிநேரம் இயங்கும் வேலைகளுக்கு, தோல்வி என்பது பெரும் அளவு வேலையை இழப்பதாகும். சோதனைச் சாவடி என்பது வேலையின் நிலையை அவ்வப்போது சேமிக்கும் ஒரு நடைமுறையாகும், இதனால் அதை முதலில் இருந்து தொடங்குவதற்குப் பதிலாக கடைசியாக சேமித்த புள்ளியிலிருந்து மீண்டும் தொடங்க முடியும்.
சோதனைச் சாவடியை எவ்வாறு செயல்படுத்துவது:
- நிலை சேமிப்பு: நீங்கள் நிலையை ஒரு எளிய கோப்பில், Redis போன்ற ஒரு கீ-வேல்யூ ஸ்டோரில் அல்லது ஒரு தரவுத்தளத்தில் சேமிக்கலாம். நிலை கடைசியாக வெற்றிகரமாகச் செயலாக்கப்பட்ட பதிவு ID, கோப்பு ஆஃப்செட் அல்லது தொகுதி எண் போன்ற எளிமையானதாக இருக்கலாம்.
- மீண்டும் தொடங்கும் தர்க்கம்: உங்கள் வேலை தொடங்கும் போது, அது முதலில் ஒரு சோதனைச் சாவடியைச் சரிபார்க்க வேண்டும். ஒன்று இருந்தால், அது அதற்கேற்ப அதன் தொடக்கப் புள்ளியை சரிசெய்ய வேண்டும் (எ.கா., கோப்புகளைத் தவிர்ப்பதன் மூலம் அல்லது ஒரு கோப்பில் ஒரு குறிப்பிட்ட நிலைக்குச் செல்வதன் மூலம்).
- அணுத்தன்மை: ஒரு தொகுதி வெற்றிகரமாக மற்றும் முழுமையாகச் செயலாக்கப்பட்டு, அதன் வெளியீடு உறுதிசெய்யப்பட்ட *பிறகு* நிலையைப் புதுப்பிக்க கவனமாக இருங்கள்.
சரியான தொகுதி அளவைத் தேர்ந்தெடுப்பது
"சிறந்த" தொகுதி அளவு ஒரு உலகளாவிய மாறிலி அல்ல; இது உங்கள் குறிப்பிட்ட பணி, தரவு மற்றும் வன்பொருளுக்கு நீங்கள் சரிசெய்ய வேண்டிய ஒரு அளவுரு. இது ஒரு சமரசம்:
- மிகவும் சிறியது: மிகச் சிறிய தொகுதி அளவு (எ.கா., 10 உருப்படிகள்) அதிக ஓவர்ஹெட்டுக்கு வழிவகுக்கும். ஒவ்வொரு தொகுதிக்கும், ஒரு குறிப்பிட்ட அளவு நிலையான செலவு உள்ளது (செயல்பாட்டு அழைப்புகள், தரவுத்தள ரவுண்ட்-டிரிப்கள் போன்றவை). சிறிய தொகுதிகளுடன், இந்த ஓவர்ஹெட் உண்மையான செயலாக்க நேரத்தை ஆதிக்கம் செலுத்தலாம், இதனால் வேலை திறமையற்றதாக மாறும்.
- மிகவும் பெரியது: மிக பெரிய தொகுதி அளவு தொகுத்தல் நோக்கத்தைத் தோற்கடிக்கிறது, இது அதிக நினைவக நுகர்வுக்கு வழிவகுக்கிறது மற்றும் `MemoryError` அபாயத்தை அதிகரிக்கிறது. இது சோதனைச் சாவடி மற்றும் பிழை மீட்டெடுப்பின் துல்லியத்தையும் குறைக்கிறது.
உகந்த அளவு இந்த காரணிகளை சமநிலைப்படுத்தும் "கோல்டிலாக்ஸ்" மதிப்பு ஆகும். ஒரு நியாயமான அனுமானத்துடன் தொடங்குங்கள் (எ.கா., சில ஆயிரம் முதல் ஒரு லட்சம் பதிவுகள், அவற்றின் அளவைப் பொறுத்து) பின்னர் உங்கள் பயன்பாட்டின் செயல்திறன் மற்றும் நினைவகப் பயன்பாட்டை வெவ்வேறு அளவுகளுடன் சோதித்து சரியான இடத்தைக் கண்டறியவும்.
முடிவு: ஒரு அடிப்படைத் திறனாக தொகுதி செயலாக்கம்
எல்லா நேரமும் விரிவடையும் தரவுத் தொகுப்புகளின் சகாப்தத்தில், பெரிய அளவில் தரவைச் செயலாக்கும் திறன் ஒரு தனிப்பட்ட சிறப்புப் பணி மட்டுமல்ல, நவீன மென்பொருள் மேம்பாடு மற்றும் தரவு அறிவியலுக்கான ஒரு அடிப்படைத் திறமையாகும். எல்லாவற்றையும் நினைவகத்தில் ஏற்றுவது என்ற எளிமையான அணுகுமுறை ஒரு பலவீனமான உத்தி ஆகும், இது தரவு அளவுகள் அதிகரிக்கும்போது தோல்வியடைய உறுதி செய்யப்பட்டுள்ளது.
பைத்தானில் நினைவக மேலாண்மையின் முக்கியக் கோட்பாடுகளிலிருந்து, ஜெனரேட்டர்களின் நேர்த்தியான சக்தியைப் பயன்படுத்தி, சிக்கலான தொகுதி மற்றும் இணைச் செயலாக்கத்திற்கான சக்திவாய்ந்த சுருக்கங்களை வழங்கும் Pandas மற்றும் Dask போன்ற தொழில்துறை தர நூலகங்களைப் பயன்படுத்துவது வரை நாம் பயணம் செய்துள்ளோம். இந்த நுட்பங்கள் கோப்புகளுக்கு மட்டுமல்லாமல் தரவுத்தள தொடர்புகளுக்கும் எவ்வாறு பொருந்தும் என்பதைப் பார்த்தோம், மேலும் ஒரு பெரிய அளவிலான சிக்கலைத் தீர்க்க அவை எவ்வாறு ஒன்றிணைகின்றன என்பதைப் பார்க்க ஒரு உண்மையான உலக ஆய்வு மூலம் நடந்துள்ளோம்.
இந்த வழிகாட்டியில் கோடிட்டுக் காட்டப்பட்டுள்ள தொகுதி செயலாக்க மனநிலையையும் கருவிகளையும் சிறந்த நடைமுறைகளையும் மாஸ்டர் செய்வதன் மூலம், வலுவான, அளவிடக்கூடிய மற்றும் திறமையான தரவு பயன்பாடுகளை உருவாக்க நீங்கள் உங்களை தயார்படுத்திக் கொள்கிறீர்கள். நினைவகச் சுவரால் கட்டுப்படுத்தப்படாமல் சவாலைச் சமாளிக்கும் திறன்கள் உங்களிடம் உள்ளன என்பதை அறிந்து, பெரிய தரவுத்தொகுப்புகளை உள்ளடக்கிய திட்டங்களுக்கு நீங்கள் நம்பிக்கையுடன் "ஆம்" என்று கூற முடியும்.